{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/gavincyi/tf-quant-finance/blob/feature%2Fswap_curve_fitting_example/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EheA5_j_cEwc"
   },
   "source": [
    "##### Copyright 2020 Google LLC.\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YCriMWd-pRTP"
   },
   "outputs": [],
   "source": [
    "#@title Licensed under the Apache License, Version 2.0 (the \"License\"); { display-mode: \"form\" }\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "# https://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OvRwFTkqcp1e"
   },
   "source": [
    "# Swap curve fitting in TensorFlow Quant Finance (TFF)\n",
    "\n",
    "TensorFlow Finance has built-in library for unconstrained numerical optimization. This notebook shows how to use it.\n",
    "\n",
    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://github.com/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "both",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 479
    },
    "colab_type": "code",
    "id": "uG8UAZXjeUhf",
    "outputId": "ab5bbaab-b39c-4953-903f-13c636a937a6"
   },
   "outputs": [],
   "source": [
    "#@title Install TF Quant Finance\n",
    "!pip install 'tensorflow>=2.1.0'\n",
    "!pip install tf-quant-finance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xmqzltQrwcDt"
   },
   "outputs": [],
   "source": [
    "#@title Imports\n",
    "from datetime import datetime\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow_probability as tfp\n",
    "import functools\n",
    "import matplotlib.colors as colors\n",
    "\n",
    "import tf_quant_finance as tff\n",
    "import tf_quant_finance.datetime as dates\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.core.pylabtools import figsize\n",
    "\n",
    "# Import seaborn if you want to have fancy visualization\n",
    "# import seaborn as sns\n",
    "# sns.set(style=\"darkgrid\")\n",
    "\n",
    "figsize(12, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build instrument cashflows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following functions are used to build the cashflows on the fixed and floating legs for curve fitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Cash instruments\n",
    "\n",
    "Cash instruments generate the cashflow by simple spot rate, i.e.\n",
    "\n",
    "$$[1 + R \\cdot \\tau] \\cdot DF(\\tau) = 1$$\n",
    "\n",
    "where $\\tau$ is the tenor of the instrument, $R$ is the market rate and $DF(\\tau)$ is the discount factor at time $\\tau$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title 1. Cash instruments\n",
    "def build_spot_cash_instrument(tenor, close, dtype, **kwargs):\n",
    "    \"\"\"Build spot cash instrument.\n",
    "    \n",
    "    Args:\n",
    "      tenor: `dates.PeriodTensor`. Defined the tenor of the floating rate.     \n",
    "      close: `float64`. Defined the close rate of the instrument.\n",
    "        \n",
    "    Returns:\n",
    "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
    "      `float_leg_start_time`.\n",
    "    \"\"\"\n",
    "    assert tenor.period_type() == dates.PeriodType.MONTH\n",
    "    tenor = tenor.quantity().numpy() / 12.0\n",
    "    return {\n",
    "        'float_leg_start_time': tf.constant([0.0], dtype=dtype),\n",
    "        'float_leg_end_time': tf.constant([tenor], dtype=dtype),\n",
    "        'float_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_start_time': tf.constant([0.0], dtype=dtype),\n",
    "        'fixed_leg_end_time': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_cashflow': tf.constant([-close], dtype=dtype),\n",
    "        'pv': 0.0,\n",
    "        'initial_curve_rate': 1e-6,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Forward and Future instruments\n",
    "\n",
    "Forward instruments, similar to cash instruments, generate the cashflow by simple spot rate on a specified forward date, i.e.\n",
    "\n",
    "$$[1 + R \\cdot \\tau(t_1, t_2)] \\cdot DF(t_2) - DF(t_1) = 0$$\n",
    "\n",
    "where $t_1$ is the forward start time, $t_2$ is the maturity time, $\\tau(t_1, t_2)$ is the tenor of the instrument, and R is the market rate.\n",
    "\n",
    "The difference between the forward and future rates is the convexity adjustment. Since the difference is minimal for instrument less then 2Y maturity, it is assumed to be the same for simplicity here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title 2. Forward and Future instruments\n",
    "def build_futures_instrument(        \n",
    "        settle_date, maturity_date, close, tenor, dtype, **kwargs):\n",
    "    \"\"\"Build futures instrument.\n",
    "    \n",
    "    Args:\n",
    "      settle_date: `datetime.datetime`. Defines the date when the instrument\n",
    "        is settled.\n",
    "      maturity_date: `datetime.datetime`. Defines the maturity date of the \n",
    "        instrument.\n",
    "      close: `float64`. Defined the close rate of the instrument.\n",
    "      tenor: `dates.PeriodTensor`. Defined the tenor of the floating rate.       \n",
    "        \n",
    "    Returns:\n",
    "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
    "      `float_leg_start_time`.\n",
    "    \"\"\"\n",
    "    assert tenor.period_type() == dates.PeriodType.MONTH\n",
    "    tenor = tenor.quantity().numpy() / 12.0\n",
    "    \n",
    "    start = daycount(\n",
    "        start_date=dates.dates_from_datetimes([settle_date]),\n",
    "        end_date=dates.dates_from_datetimes([maturity_date]),\n",
    "        dtype=dtype\n",
    "    )\n",
    "    \n",
    "    return {\n",
    "        'float_leg_start_time': start,\n",
    "        'float_leg_end_time': start + tenor,\n",
    "        'float_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_start_time': start,\n",
    "        'fixed_leg_end_time': start + tenor,\n",
    "        'fixed_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_cashflow': tf.constant([-close], dtype=dtype),\n",
    "        'pv': 0.0,\n",
    "        'initial_curve_rate': 1e-6,\n",
    "    }    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Swap instruments\n",
    "\n",
    "Given a pre-defined notional principal $K$, the present value of the fixed leg can be expressed as\n",
    "\n",
    "$$ PV(fixed) = \\sum_{i=1}^{N_{fixed}} [K \\cdot R \\cdot \\tau(i) \\cdot DF(t_i)] + K \\cdot DF(t_{N_{fixed}}) $$\n",
    "\n",
    "where $R$ is the market rate, $N_{fixed}$ is the total number of fixed leg payments, $\\tau(i)$ is the day count fraction that determines the $i^{th}$ payment amount, $DF(t_1)$ is the discount factor at $i^{th}$ payment time t. \n",
    "\n",
    "Same for the present value of the floating leg\n",
    "\n",
    "$$ PV(floating) = \\sum_{i=1}^{N_{floating}} [K \\cdot R(i) \\cdot \\tau(i) \\cdot DF(t_i)] + K \\cdot DF(t_{N_{floating}}) $$\n",
    "\n",
    "where $R(i)$ is an effective rate to cover $i^{th}$ payment on the floating leg.\n",
    "\n",
    "Under the no-arbitrage rule, the present value of the fixed and floating leg must be equal, i.e.\n",
    "\n",
    "$$ PV(fixed) = PV(floating) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title 3. Swap instruments\n",
    "def build_swap_instrument(\n",
    "        settle_date, maturity_date, close, fixed_tenor, float_tenor, daycount,\n",
    "        roll_convention, dtype, **kwargs):\n",
    "    \"\"\"Build futures instrument.\n",
    "    \n",
    "    Args:\n",
    "      settle_date: `datetime.datetime`. Defines the date when the instrument\n",
    "        is settled.\n",
    "      maturity_date: `datetime.datetime`. Defines the maturity date of the \n",
    "        instrument.\n",
    "      close: `float64`. Defined the close rate of the instrument.\n",
    "      fixed_tenor: `float64`. Defined the tenor of the fixed rate.\n",
    "      float_tenor: `float64`. Defined the tenor of the floating rate.\n",
    "      daycount: `callable`. Defines the daycount convention function imported\n",
    "          from `dates.daycounts`.\n",
    "      roll_convention: `dates.BusinessDayConvention`. Defines the roll\n",
    "          convention.\n",
    "      dtype: `tf.Dtype`. If supplied the dtype for the (elements of)\n",
    "        `float_leg_start_times`, and `fixed_leg_start_times`.\n",
    "        Default value: None which maps to the default dtype inferred by\n",
    "        TensorFlow.   \n",
    "          \n",
    "    Returns:\n",
    "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
    "      `float_leg_start_time`.\n",
    "    \"\"\"    \n",
    "    settle_date = dates.dates_from_datetimes([settle_date])\n",
    "    maturity_date = dates.dates_from_datetimes([maturity_date])\n",
    "    float_leg_dates = dates.PeriodicSchedule(\n",
    "        start_date=settle_date,\n",
    "        end_date=maturity_date,\n",
    "        tenor=float_tenor,\n",
    "        roll_convention=roll_convention,\n",
    "        backward=False).dates()[0]  \n",
    "    fixed_leg_dates = dates.PeriodicSchedule(\n",
    "        start_date=settle_date,\n",
    "        end_date=maturity_date,\n",
    "        tenor=fixed_tenor,\n",
    "        roll_convention=roll_convention,\n",
    "        backward=False).dates()[0]          \n",
    "        \n",
    "    return {\n",
    "        'float_leg_start_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=float_leg_dates[:-1],\n",
    "            dtype=dtype),\n",
    "        'float_leg_end_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=float_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'float_leg_daycount': daycount(\n",
    "            start_date=float_leg_dates[:-1],\n",
    "            end_date=float_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_start_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=fixed_leg_dates[:-1],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_end_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=fixed_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_daycount': daycount(\n",
    "            start_date=fixed_leg_dates[:-1],\n",
    "            end_date=fixed_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_cashflow': tf.repeat(\n",
    "            tf.constant(-close, dtype=dtype), \n",
    "            repeats=fixed_leg_dates.shape[0] - 1, \n",
    "        ),\n",
    "        'pv': 0.0,\n",
    "        'initial_curve_rate': 1e-6,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the interest rate curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data is retrieved from Bloomberg on 2020-02-14 to fit the USD LIBOR 3M curve. \n",
    "\n",
    "The following market instruments are used\n",
    "\n",
    "- LIBOR Fixed 3 Month: Spot LIBOR 3M rate\n",
    "\n",
    "- ED Futures: Eurodollar Futures with expiry up to 2Y\n",
    "\n",
    "- Interest Rate Swap: Liquid interest rate swap instruments with tenors from 2 years to 50 years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float_leg_start_times = []\n",
    "float_leg_end_times = []\n",
    "float_leg_daycounts = []\n",
    "fixed_leg_start_times = []\n",
    "fixed_leg_end_times = []\n",
    "fixed_leg_daycounts = []\n",
    "fixed_leg_cashflows = []\n",
    "pvs = []\n",
    "initial_curve_rates = []\n",
    "\n",
    "# Global dtype\n",
    "dtype = tf.float64\n",
    "\n",
    "# Global daycount - Fit on USD curve\n",
    "daycount = dates.daycount_actual_360\n",
    "\n",
    "# Global roll convention - Backward\n",
    "roll_convention = dates.BusinessDayConvention.PRECEDING\n",
    "\n",
    "# The fixed leg payment frequency is 6M\n",
    "fixed_tenor = dates.months(6)\n",
    "\n",
    "# The floating rate is always USD LIBOR 3M\n",
    "float_tenor = dates.months(3)\n",
    "\n",
    "instruments = [\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-05-21', \n",
    "     'close': 0.01696000000, 'name': 'USD3MD'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-06-17', \n",
    "     'close': 0.01669900000, 'name': 'EDH0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-09-16', \n",
    "     'close': 0.01544400000, 'name': 'EDM0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-12-16', \n",
    "     'close': 0.01468600000, 'name': 'EDU0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-03-17', \n",
    "     'close': 0.01427500000, 'name': 'EDZ0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-06-16', \n",
    "     'close': 0.01326200000, 'name': 'EDH1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-09-15', \n",
    "     'close': 0.01299700000, 'name': 'EDM1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-12-15', \n",
    "     'close': 0.01277900000, 'name': 'EDU1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-03-16', \n",
    "     'close': 0.01295900000, 'name': 'EDZ1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-06-15', \n",
    "     'close': 0.01288600000, 'name': 'EDH2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-09-21', \n",
    "     'close': 0.01295900000, 'name': 'EDM2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-12-21', \n",
    "     'close': 0.01308200000, 'name': 'EDU2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2023-03-15', \n",
    "     'close': 0.01335500000, 'name': 'EDZ2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2024-02-21', \n",
    "     'close': 0.01378410000, 'name': 'USDAM3L4Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2025-02-21', \n",
    "     'close': 0.01384037500\n",
    "     , 'name': 'USDAM3L6Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2027-02-22', \n",
    "     'close': 0.01419340000, 'name': 'USDAM3L7Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2028-02-22', \n",
    "     'close': 0.01443062500, 'name': 'USDAM3L8Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2029-02-21', \n",
    "     'close': 0.01468025000, 'name': 'USDAM3L9Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2030-02-21', \n",
    "     'close': 0.01494412500, 'name': 'USDAM3L10Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2032-02-23', \n",
    "     'close': 0.01542162500, 'name': 'USDAM3L12Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2035-02-21', \n",
    "     'close': 0.01592825000, 'name': 'USDAM3L15Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2040-02-21', \n",
    "     'close': 0.01644683333, 'name': 'USDAM3L20Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2045-02-21', \n",
    "     'close': 0.01666350000, 'name': 'USDAM3L25Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2050-02-22', \n",
    "     'close': 0.01662650000, 'name': 'USDAM3L30Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2060-02-23', \n",
    "     'close': 0.01613000000, 'name': 'USDAM3L40Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2070-02-21', \n",
    "     'close': 0.01534000000, 'name': 'USDAM3L50Y'},\n",
    "]\n",
    "\n",
    "for instrument in instruments:\n",
    "    instrument['settle_date'] = (\n",
    "        datetime.strptime(instrument['settle_date'], '%Y-%m-%d')\n",
    "    )\n",
    "    instrument['maturity_date'] = (\n",
    "        datetime.strptime(instrument['maturity_date'], '%Y-%m-%d')\n",
    "    )    \n",
    "    if instrument['name'] == 'USD3MD':\n",
    "        # Spot instrument\n",
    "        instrument = build_spot_cash_instrument(\n",
    "            tenor=float_tenor, \n",
    "            dtype=dtype,\n",
    "            **instrument\n",
    "        )\n",
    "    elif instrument['name'][:2] == 'ED':\n",
    "        # Futures instrument\n",
    "        instrument = build_futures_instrument(\n",
    "            dtype=dtype,\n",
    "            tenor=float_tenor, \n",
    "            **instrument\n",
    "        )\n",
    "    elif instrument['name'].startswith('USDAM3L'):\n",
    "        # Swap instrument\n",
    "        instrument = build_swap_instrument(\n",
    "            fixed_tenor=fixed_tenor,\n",
    "            float_tenor=float_tenor,\n",
    "            roll_convention=roll_convention,\n",
    "            daycount=daycount,\n",
    "            dtype=dtype,\n",
    "            **instrument\n",
    "        )\n",
    "    else:\n",
    "        raise NotImplementedError(\n",
    "            'Cannot recognize the type of instrument %s'\n",
    "            % instrument['name']\n",
    "        )\n",
    "    \n",
    "    float_leg_start_times.append(instrument['float_leg_start_time'])\n",
    "    float_leg_end_times.append(instrument['float_leg_end_time'])\n",
    "    float_leg_daycounts.append(instrument['float_leg_daycount'])\n",
    "    fixed_leg_start_times.append(instrument['fixed_leg_start_time'])\n",
    "    fixed_leg_end_times.append(instrument['fixed_leg_end_time'])\n",
    "    fixed_leg_daycounts.append(instrument['fixed_leg_daycount'])\n",
    "    fixed_leg_cashflows.append(instrument['fixed_leg_cashflow'])\n",
    "    pvs.append(instrument['pv'])\n",
    "    initial_curve_rates.append(instrument['initial_curve_rate'])\n",
    "    \n",
    "curve = tff.rates.swap_curve_fit(\n",
    "    float_leg_start_times=float_leg_start_times,\n",
    "    float_leg_end_times=float_leg_end_times,\n",
    "    float_leg_daycount_fractions=float_leg_daycounts,\n",
    "    fixed_leg_start_times=fixed_leg_start_times,\n",
    "    fixed_leg_end_times=fixed_leg_end_times,\n",
    "    fixed_leg_cashflows=fixed_leg_cashflows,\n",
    "    fixed_leg_daycount_fractions=fixed_leg_daycounts,\n",
    "    present_values=tf.constant(pvs, dtype=dtype),\n",
    "    initial_curve_rates=tf.constant(initial_curve_rates, dtype))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(curve.times, curve.rates)\n",
    "plt.title('Discount Rate Curve', fontsize=20)\n",
    "plt.xlabel('Time', fontsize=18)\n",
    "plt.ylabel('Discount Rate', fontsize=18)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] Bloomberg, Building the Bloomberg Interest Rate Curve – Definitions and Methodology, Mar 2016"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Swap Curve Fitting.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
